// bzoj3037
// 题意： 给定n个元素，每个元素可以唯一控制其他某一个元素，现在上帝要将
//        一部分元素放到世界，但是要保证放出去的元素至少还有一个控制它
//        的元素在上帝手中。问最多可以放出去多少元素。
//
// 题解： 原图是一个内向树+基环。这个控制关系有点像支配集，所以反过来求
//        最小支配集个数为s，答案就是n-s。求树的支配集用树形dp可以做，大概
//        维护取这点和不取这点子树的最小支配集个数。对于基环可以随便去掉
//        一条边然后讨论就好。假如去掉边是x->y，那么x取则y初始被支配，f[y][0]
//        初始值为0, 不用强制选地一个，否则正常求支配集，f[y][0]初始值为inf，
//        强制取第一个儿子然后不断更新，以保证至少有一个儿子被取。
//
// run: $exec < input
#include <cstdio>
#include <algorithm>

int const maxn = 1000007;
int const inf = 1 << 29;
int head[maxn], next[maxn], end_point[maxn];
bool ignore[maxn];
int alloc = 1;
int a[maxn];
bool vis[maxn];
int f[maxn][2];  // 1 take, 0 not
int n, ans, root, conquered;

void add_edge(int x, int y)
{
	end_point[alloc] = y; next[alloc] = head[x]; head[x] = alloc++;
}

void dfs(int x)
{
	vis[x] = true;
	if (vis[a[x]]) root = x;
	else 		   dfs(a[x]);
}

void tree_dp(int x)
{
	vis[x] = true;
	f[x][1] = 1;
	f[x][0] = inf;
	if (x == conquered) f[x][0] = 0;
	for (int p = head[x]; p; p = next[p]) {
		int y = end_point[p];
		if (ignore[y]) continue;
		tree_dp(y);
		f[x][0] += std::min(f[y][0], f[y][1]);
		f[x][0]  = std::min(f[x][0], f[x][1] + f[y][1] - 1); // this line is fantastic
		f[x][1] += std::min(f[y][0], f[y][1]);
	}
}

int main()
{
	std::scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		std::scanf("%d", &a[i]);
		add_edge(--a[i], i);
	}

	for (int i = 0; i < n; i++) {
		if (vis[i]) continue;
		dfs(i);
		ignore[root] = true;
		conquered = a[root];
		tree_dp(root);
		int tmp = f[root][1];
		conquered = -1;
		tree_dp(root);
		tmp = std::min(tmp, f[root][0]);
		ans += tmp;
	}
	std::printf("%d\n", n - ans);
}

